Using Windows
Volume Number: 1
Issue Number: 4
Column Tag: C Workshop
By Robert B. Denny
Layers and Interfaces
One of the most important things to come out of the computer world in the
s eventies is the concept of layered architecture. Layering provides us with a clean way
to deal with the complexities of modern operating system and communications
architectures. One of the most visible instances of layering is the ISO Open Systems
Architecture which is widely used and quoted in standards for networks.
I consider layering to be a survival skill for software developers. Take time to
consider the Macintosh from bottom to top. At the bottom, we have solid-state physics
which attempts to explain the behavior of what might be particles or waves. At the top
(user’s view) we have dragging, clicking, icons, windows, etc. Both the physics and
the user concepts are abstract ideas. How many layers can you conceive of in a
Macintosh?
Let’s formalize this a bit. A layer is a structured set of related things that
together provide a set of tools or services for implementing other things. An interface
is a set of means for accessing the services provided by a layer. Finally a given layer
might make use of the services provided by a “lower” layer in implementing it’s own
services. It is this latter notion that makes layers have ranking.
How does all of this help us deal with complex systems? By restricting our
thinking to the layer we are working on, we avoid cluttering our mind with
unnecessary details. This kind of thinking comes naturally, but we can reinforce it by
being aware of it’s importance.
Most of the developers I have talked with share the feeling that the Mac is a
difficult system to learn. Inside Macintosh is a wealth of information, but it has little
overall structure. There is a section called Inside Macintosh: A Road Map which does
discuss the overall architecture, but this thread is not carried elsewhere, and one
tends to “dive in” to a particular area of interest.
Here is my personal view of the Macintosh operating system as a set of layers.
Below these layers are the low-level stuff I seldom deal with and above these layers
are the programs I write. The boxes show the sections of the Mac system that I
frequently encounter when developing user-oriented applications.
Data-Driven Software
Another key concept needeed for Macintosh programming is that of data or
table-driven software. This is another common technique that grew out of the
s eventies, when system complexity took a quantum jump.
A data-driven routine consists of a combination of code and data, split up so that
variations are possible with no changes to the code. This technique is usually employed
where there are a variety of related objects that need some sort of service or
management that can be done with a common “engine” in code.
This is sort of a gray area; you might say that all routines are sensitive to data,
or they wouldn’t be useful. True, but a routine that stores no data of it’s own is special.
It is usually called with a reference to a data structure which contains the state and
attributes of the particular object that the routine is to work on. The data structure
could even contain a reference to one or more “action routines” which are unique to
the object in question. Examining the contents of such data structures can often
provide great insight into the sublties of the routine or service.
Most of the “ managers” in the Macintosh interface use this technique. The data
structures are referred to as “ records” from the Pascal terminology. In C, they can
be implemented as struct’s.
The Window Manager
From the user’s viewpoint, a window is an object on the desktop that provides
some sort of user interface. There is a whole set of guidelines describing how windows
should look and behave. Window appearance and behavior is the essence of the
Macintosh.
From the developer’s viewpoint, a window is a structured set of regions in a port
under the control of the Window Manager. The Window Manager provides a layered
interface to window services on the Macintosh, using QuickDraw to draw the pictures
that create the abstract notion of windows on the screen.
Besides handling the windows themselves, the Window Manager handles shuffling,
dragging and re-sizing of overlapping windows, generating events for owning
applications to update window contents as required. This powerful and complex layer of
the Mac architecture has a surprisingly simple interface.
The Window Manager uses a data structure, called a window record, to keep track
of each window. It contains the currrent attributes and state of the corresponding
window. The window records are kept on a linked list whose order corresponds to the
planar ordering of the window images on the screen, as shown in figure 2.
If you haven’t looked over the section on the Window Manager in Inside
Macintosh, now would be a good time to do so. In particular, study the section
describing the window record and each of it’s fields. We’ll look at some of the more
important fields here, but we can’t cover them all. In C, the window record can be
represented as follows:
C STRUCT FOR WINDOW RECORDS
#define boolean char
struct WindowRec
{
grafPort port;
short windowKind;
boolean visible;
boolean hilited;
boolean goAwayFlag;
boolean spareFlag;
RgnHandle strucRgn;
RgnHandle contRgn;
RgnHandle updateRgn;
Handle windowDefProc;
Handle dataHandle;
Handle titleHandle;
short titleWidth;
Handle controlList;
struct WindowRec *nextWindow;
PicHandle windowPic;
long refCon;
};
Note that the first thing in the window record is a GrafPort structure. This is the
data structure used by QuickDraw for manipulating “ports” in general. Of course, a
window is a port, so it follows that the window’s data would include (nested within) a
GrafPort.
Before we dig any deeper into the window record, lets look at how it relates to
other important data structures. Pointers and handles are represented alike in the
interest of simplicity in Fig. 3.
PORTS, REGIONS AND WINDOWS
Looking at figure 3, observe the linkage of the region structs. The visRgn and
clipRgn are hooked to the GrafPort, while the strucRgn, contRgn and updateRgn are
hooked to the WindowRecord. The latter three regions are used only in the context of a
window. If you are unclear about the role of regions, refer to Chris Derossi’s Pascal
Procedures in MacTutor, Vol.1, No.3, February, 1985.
Note also that the ControlRecord for each control that is associated with the
window is hooked to a linked list, and has a “back-link” pointing back to the owning
window’s WindowRecord. This implies that the Window Manager uses information
about the controls, and that the Control Manager uses information about the owning
window and it’s port. For example, the Window Manager function drawControls()
traces down the linked list of ControlRecords, drawing each control in turn.
The various “boolean” fields in the WindowRecord indicate the current state of
the window’s visibility, highlighting (see below) and whether it has a “go-away” box.
CAUTION: the Window Manager uses 255 as TRUE and 0 as FALSE. Typically C defines
TRUE as 1. You should test these flags for “not FALSE”, rather than explicitly TRUE.
The three RgnHandles point to Rgn structs which describe important parts of the
window’s port. We’ll cover these later in the section on anatomy and next month’s
column on window dynamics.
The windowDefProc field is a handle that points to a vectored set of routines that
give the window it’s look. Associated with this is the dataHandle field, which points to
private data used by the DefProc. “DefProc” is short for Definition Procedure, really
a set of routines that perform the following:
Window Definition Procedure Tasks
• Draw window frame
• Return region where mouse was clicked
• Calculate structure & content regions
• Draw “grow” image of the window
• Draw a “size box” in the content region
Note that the Window Manager has no idea what the window actually looks like.
The appearance is completely governed by the DefProc, which is described by a handle
in the WindowRecord. The six standard DefProcs handle windows of the types shown
below in figure 5 with the symbolic value for the definition ID you pass to the Window
Manager when creating the window.
Note that the documentProc flavor has the outlines for scroll bars. Scrollers are
controls, not part of the basic window’s definition. These are the standard window
types. You could write a DefProc package for a custom window type. The hooks for this
are described in Inside Macintosh in the Window Manager section.
The titleHandle field points to the window’s title string and the titleWidth field
contains the width of the title in pixels. ControlList is the listhead for the linked list of
ControRecords for the controls associated with this window.
NextWindow is a pointer to the next window on the window list. As we stated
earlier, the “next” window is the one behind this window. If this is the back-most
window, NextWindow is NULL.
WindowPic is a handle to a QuickDraw picture for the window, or NULL if the
application is responsible for updating the window. This implies that the window
manager will automatically update a window if it’s contents are a QuickDraw Picture
without generating update events.
Finally, there is a “hack” in the definitions used in Inside Macintosh. A
WindowPtr is defined as a pointer to a grafPort, rather than a pointer to a
WindowRecord. The name for the later is WindowPeek. It seems that the most frequent
use of WindowRecord information involves the data contained in the embedded grafPort.
Keep this quirk in mind.
Anatomy of a Document Window
The six standard window types are shown in figure 5. Of the six, the
documentProc type is the most complex. In this section we’ll look at the window as a
set of regions. Viewing the window this way is essential when writing programs which
manipulate them, particularly the routines that handle activation and updating of the
window. A document window with scroll bars is shown in figure 6.
All windows have a structure region and a content region. The structure region
covers the entire window, frame and all. The content region is the area inside the
frame. These regions change only when the window is moved or re-sized.
The frame may include go-away and drag regions. The content region may include
a grow region.These are not really regions in the formal sense, as defined by
QuickDraw. The DefProc is responsible for handling these regions, not QuickDraw. The
scroll bars are handled by the Control Manager, not the Window Manager.
The WindowRecord contains a handle to another region, the Update Region. This
region describes the portion of the content region that needs updating, redrawing, after
some change. We’ll deal with this in next month’s column on window dynamics.
One of the fine points not made clear in Inside Macintosh is the relationship
between the “grow image”, the grow region and the scroll bars usually present in a
document window. The grow image is the line-tracing of the window that appears when
you click in the grow region.
The Control Manager can build scroll bars of any dimension. The convention is
that scroll bars are 16 pixels wide. This matches the width of the “scroller” areas
that appear in the grow image, and the width and height of the grow icon. These areas
are fixed, set by the documentProc DefProc. Here is a fat-bits view of the lower right
corner of the document window shown above (see fig. 7). Note that the scroll bar edges
overlap the grow icon and the window frame by one pixel. The following fragment of C
code computes the boundsRects for the scrollers, given the portRect for the window.
Get the portRect from the grafPort that is embedded in the WindowRecord:
struct rect /* Define a “rect” */
{
short top;
short left;
short bottom;
short right;
};
struct grafPort *wp; /* Window Pointer */
struct rect *pr; /* -> portRect */
struct rect vs_rect; /* Vert. scroller */
struct rect hs_rect; /* Hor. scroller */
pr = &(wp->portRect);
/*
* Compute bounds rect for vertical scroll
*/
vs_rect.top = pr->top - 1;
vs_rect.left = pr->right - 15;
vs_rect.bottom = pr->bottom - 14;
vs_rect.right - pr->right + 1;
/*
* Compute bounds rect for horiz. scroll
*/
hs_rect.top = pr->bottom - 15;
hs_rect.left = pr->left - 1;
hs_rect.bottom = pr->bottom + 1;
hs_rect.right = pr->right - 14;
Afterword
Next month we’ll deal with window dynamics, dragging, growing, updating and
activating. This is an area of Mac programming that seems complex on the surface. If
you have tried your hand at window-oriented programs, you probably had many
surprises and mysteries and you may have developed a few OPT’s (old programmer’s
tales). One of my most memorable surprises was discovering what happens if you omit
the beginUpdate() and endUpdate() calls when handling an update event.
There is an underlying consistency to window dynamics. It’s all there in Inside
Macintosh, but in peices. Understanding window dynamics is essential if you are to get
beyond trivial programs without unnecessary screen drawing or ugly hacks. See you
then.
